"""
问题分析服务
"""
import logging
import json
from typing import Dict, Any

from backend.services.ai_service import get_ai_service
from backend.models.core import Question, QuestionAnalysis, ExecutionResult
from shared.enums import ComplexityLevel, QuestionCategory

logger = logging.getLogger(__name__)


class QuestionAnalyzer:
    """问题分析器 - 分析问题复杂度和类型"""
    
    def __init__(self):
        self.analysis_prompt_template = """
请分析以下问题的复杂度和类型，并返回JSON格式的分析结果。

问题：{question}

请从以下维度分析：

1. 复杂度级别（complexity）：
   - simple: 简单问题，可以直接回答
   - moderate: 中等复杂度，需要一些分析
   - complex: 复杂问题，需要多步骤分析和推理

2. 问题类型（category）：
   - factual: 事实性问题
   - analytical: 分析性问题
   - creative: 创造性问题
   - procedural: 程序性问题
   - comparative: 比较性问题
   - predictive: 预测性问题

3. 建议处理方式（suggested_approach）：简要描述如何处理这个问题
4. 关键主题（key_topics）：问题涉及的主要主题列表
5. 预估任务数（estimated_tasks）：如果需要分解，预估需要多少个子任务
6. 置信度（confidence）：分析结果的置信度（0-1）
7. 推理过程（reasoning）：分析的推理过程

请严格按照以下JSON格式返回：
{{
    "complexity": "simple|moderate|complex",
    "category": "factual|analytical|creative|procedural|comparative|predictive",
    "suggested_approach": "建议的处理方式",
    "key_topics": ["主题1", "主题2"],
    "estimated_tasks": 数字,
    "confidence": 0.0-1.0,
    "reasoning": "推理过程说明"
}}

只返回JSON，不要其他内容。
"""
    
    async def analyze_complexity(self, question: str) -> ComplexityLevel:
        """分析问题复杂度"""
        analysis = await self.analyze_with_ai(question)
        return analysis.complexity if analysis else ComplexityLevel.SIMPLE
    
    async def categorize_question(self, question: str) -> QuestionCategory:
        """问题分类"""
        analysis = await self.analyze_with_ai(question)
        return analysis.category if analysis else QuestionCategory.FACTUAL
    
    async def analyze_with_ai(self, question: str) -> QuestionAnalysis:
        """使用AI进行问题分析"""
        try:
            prompt = self.analysis_prompt_template.format(question=question)
            
            result = await get_ai_service().generate_text(
                prompt,
                temperature=0.3,  # 较低的温度以获得更一致的结果
                max_tokens=800
            )
            
            if not result.success:
                logger.error(f"AI analysis failed: {result.error}")
                return self._get_default_analysis()
            
            # 解析JSON响应
            try:
                analysis_data = json.loads(result.result.strip())
                return self._parse_analysis_result(analysis_data)
            except json.JSONDecodeError as e:
                logger.error(f"Failed to parse AI analysis JSON: {e}")
                logger.error(f"AI response: {result.result}")
                return self._get_default_analysis()
                
        except Exception as e:
            logger.error(f"Question analysis failed: {e}")
            return self._get_default_analysis()
    
    def _parse_analysis_result(self, data: Dict[str, Any]) -> QuestionAnalysis:
        """解析分析结果"""
        try:
            return QuestionAnalysis(
                complexity=ComplexityLevel(data.get('complexity', 'simple')),
                category=QuestionCategory(data.get('category', 'factual')),
                suggested_approach=data.get('suggested_approach', ''),
                key_topics=data.get('key_topics', []),
                estimated_tasks=data.get('estimated_tasks', 1),
                confidence=float(data.get('confidence', 0.5)),
                reasoning=data.get('reasoning', '')
            )
        except (ValueError, KeyError) as e:
            logger.error(f"Failed to parse analysis data: {e}")
            return self._get_default_analysis()
    
    def _get_default_analysis(self) -> QuestionAnalysis:
        """获取默认分析结果"""
        return QuestionAnalysis(
            complexity=ComplexityLevel.SIMPLE,
            category=QuestionCategory.FACTUAL,
            suggested_approach="直接回答问题",
            key_topics=[],
            estimated_tasks=1,
            confidence=0.5,
            reasoning="使用默认分析结果"
        )


class SimpleQuestionHandler:
    """简单问题处理器"""
    
    def __init__(self):
        self.simple_prompt_template = """
请回答以下问题，提供准确、简洁的答案：

问题：{question}

请直接回答问题，不需要过多解释。如果问题涉及具体的事实或数据，请尽量提供准确信息。
"""
    
    async def handle_simple_question(self, question: str) -> ExecutionResult:
        """处理简单问题"""
        try:
            prompt = self.simple_prompt_template.format(question=question)
            
            result = await get_ai_service().generate_text(
                prompt,
                temperature=0.5,
                max_tokens=2000
            )
            
            if result.success:
                logger.info("Simple question handled successfully")
            else:
                logger.error(f"Simple question handling failed: {result.error}")
            
            return result
            
        except Exception as e:
            logger.error(f"Simple question handler error: {e}")
            return ExecutionResult(
                success=False,
                error=str(e)
            )


# 全局实例
question_analyzer = QuestionAnalyzer()
simple_question_handler = SimpleQuestionHandler()